home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 19 / CU Amiga Magazine's Super CD-ROM 19 (1998)(EMAP Images)(GB)[!][issue 1998-02].iso / CUCD / Programming / LEDA / source / src / x11 / _x11.c next >
Encoding:
C/C++ Source or Header  |  1994-11-16  |  16.6 KB  |  704 lines
  1. /*******************************************************************************
  2. +
  3. +  LEDA  3.1c
  4. +
  5. +
  6. +  _x11.c
  7. +
  8. +
  9. +  Copyright (c) 1994  by  Max-Planck-Institut fuer Informatik
  10. +  Im Stadtwald, 6600 Saarbruecken, FRG     
  11. +  All rights reserved.
  12. + 
  13. *******************************************************************************/
  14.  
  15.  
  16.  
  17. // basic graphic routines for libWx declared in <LEDA/impl/x_basic.h>
  18. // implemented using the X11 library functions (libX11)
  19.  
  20.  
  21. #include <LEDA/impl/x_basic.h>
  22.  
  23. #include <iostream.h>
  24.  
  25. #include <X11/X.h>
  26. #include <X11/Xlib.h>
  27. #include <X11/Xutil.h>
  28.  
  29. #include <stdio.h>
  30. #include <string.h>
  31. #include <stdlib.h>
  32. #include <math.h>
  33.  
  34. #include <LEDA/bitmaps/leda_icon.xbm>
  35.  
  36.  
  37. static char dot_mask[2] = { 1,4 };
  38. static char dash_mask[2] = { 4,4 };
  39.  
  40. static char* text_font_name = "screen16";
  41. static char* bold_font_name = "screen-bold16";
  42. static char* mesg_font_name = "10x20";
  43.  
  44. static char* text_font_name2 = "9x15";
  45. static char* bold_font_name2 = "9x15bold";
  46. static char* mesg_font_name2 = "lucidasans20";
  47.  
  48.  
  49.  
  50. static Display     *display = NULL;
  51. static int          screen;
  52. static XEvent       event;
  53. static XGCValues    gc_val;
  54. static GC           gc;
  55. static Colormap     color_map;
  56.  
  57. static XFontStruct *text_font;
  58. static XFontStruct *bold_font;
  59. static XFontStruct *mesg_font;
  60. static XFontStruct *current_font;
  61.  
  62. static int mesg_char_width;
  63. static int bold_char_width;
  64. static int text_char_width;
  65. static int current_char_width;
  66.  
  67. const  int MAX_COLORS = 256; 
  68. static unsigned long color_pix[MAX_COLORS];
  69. static char* color_name[MAX_COLORS];
  70. static int color_count= 0;
  71.  
  72. static int LINESTYLE = 0;
  73. static int MODE      = 0;
  74. static int COLOR     = 1;
  75.  
  76.  
  77. static int get_char_width(XFontStruct* fp)
  78. { XCharStruct char_struct;
  79.   int asc, desc, dir;
  80.   XQueryTextExtents(display,fp->fid,"H",1, &dir,&asc,&desc,&char_struct);
  81.   return char_struct.width;
  82. }
  83.  
  84.  
  85. void open_display(void)
  86. { 
  87.   if (display!=NULL) return;
  88.  
  89.   if ((display = XOpenDisplay(0)) == NULL)    
  90.   { fprintf(stderr, "Can\'t open display: \n");
  91.     abort();
  92.    }
  93.  
  94.   screen    = DefaultScreen(display);
  95.   color_map = DefaultColormap(display,screen);
  96.   gc        = DefaultGC(display,screen);
  97.  
  98.  
  99.   if ((text_font = XLoadQueryFont(display,text_font_name)) == NULL)
  100.   if ((text_font = XLoadQueryFont(display,text_font_name2)) == NULL)
  101.   { fprintf(stderr,"Error: Cannot load text font");
  102.     exit(1);
  103.    }
  104.  
  105.   if ((bold_font = XLoadQueryFont(display,bold_font_name)) == NULL)
  106.   if ((bold_font = XLoadQueryFont(display,bold_font_name2)) == NULL)
  107.   { fprintf(stderr,"Error: Cannot load bold font");
  108.     exit(1);
  109.    }
  110.  
  111.   if ((mesg_font = XLoadQueryFont(display,mesg_font_name)) == NULL)
  112.   if ((mesg_font = XLoadQueryFont(display,mesg_font_name2)) == NULL)
  113.   { fprintf(stderr,"Error: Cannot load message font\n");
  114.     exit(1);
  115.    }
  116.  
  117.  
  118.   XSetLineAttributes(display,gc,1,LineSolid,CapButt,JoinMiter);
  119.  
  120.  
  121.   // 16 predefined colors from /usr/lib/X11/rgb.txt
  122.  
  123.   color_count = 0;
  124.  
  125.   new_color("white");          // 0: white
  126.   new_color("black");          // 1: black
  127.   new_color("red");            // 2: red
  128.   new_color("green");          // 3: green
  129.   new_color("blue");           // 4: blue
  130.   new_color("yellow");         // 5: yellow
  131.   new_color("purple");         // 6: violet
  132.   new_color("darkorange");     // 7: orange
  133.   new_color("cyan");           // 8: cyan
  134.   new_color("sienna");         // 9: brown
  135.   new_color("magenta");        //10: pink 
  136.   new_color("forestgreen");    //11: darkgreen
  137.   new_color("cornflowerblue"); //12: darkblue 
  138.   new_color("grey75");         //13: grey1
  139.   new_color("grey60");         //14: grey2
  140.   new_color("grey45");         //15: grey3
  141.  
  142.   gc_val.foreground = color_pix[1];
  143.   gc_val.function  = GXor; 
  144.   gc_val.line_style = LineSolid;
  145.   gc_val.line_width = 1;
  146.   gc_val.font = text_font->fid;
  147.   XChangeGC(display,gc,
  148.             GCForeground|GCFunction|GCLineStyle|GCLineWidth|GCFont,&gc_val);
  149.  
  150.   text_char_width = get_char_width(text_font);
  151.   bold_char_width = get_char_width(bold_font);
  152.   mesg_char_width = get_char_width(mesg_font);
  153.   current_char_width = text_char_width;
  154.   current_font = text_font;
  155. }
  156.  
  157.  
  158. static char* duplicate_string(const char* p)
  159. { char* q = new char[strlen(p)+1];
  160.   strcpy(q,p);
  161.   return q;
  162. }
  163.  
  164. int new_color(const char* name)
  165. { 
  166.   open_display();
  167.  
  168.   // first test if color has been allocated before
  169.  
  170.   for(int i = 0; i < color_count; i++)
  171.      if (strcmp(color_name[i],name)==0) break;
  172.   if (i < color_count) return i;
  173.   
  174.   // if not, try to allocate it
  175.  
  176.   if (color_count == MAX_COLORS) return 0;
  177.  
  178.   XColor xcolor;
  179.  
  180.   if (DefaultDepth(display,screen)==1 && strcmp(name,"white")!=0) 
  181.      XParseColor(display, color_map, "black", &xcolor);
  182.   else
  183.      XParseColor(display, color_map, name, &xcolor);
  184.  
  185.   XAllocColor(display,color_map,&xcolor);
  186.   color_pix[color_count] = xcolor.pixel;
  187.   char* p = new char[strlen(name)+1];
  188.   strcpy(p,name);
  189.   color_name[color_count] = p;
  190.   return color_count++;
  191. }
  192.  
  193.   
  194.  
  195. Window open_window(int x, int y, int width, int height, const char* header,
  196.                                                         const char* label)
  197. {
  198.   Window win;
  199.   XEvent e;
  200.   XSetWindowAttributes attrib;
  201.   XSizeHints size_hints;
  202.   XWMHints wm_hints;
  203.   Pixmap icon_pixmap;
  204.  
  205.   attrib.backing_store = Always;
  206.  
  207.   win= XCreateWindow(display, RootWindow(display, screen), x, y,
  208.                            width,height,2,DefaultDepth(display,screen),
  209.                            InputOutput, DefaultVisual(display,screen), 
  210.                            CWBackingStore, &attrib);
  211.  
  212.   XSelectInput(display,win, KeyPressMask    | PointerMotionMask  | 
  213.                             ButtonPressMask | ButtonReleaseMask  |
  214.                             ExposureMask    | StructureNotifyMask ); 
  215.   
  216.   XSetWindowBackground(display,win, WhitePixel(display, screen)); 
  217.  
  218.   XStoreName(display,win,header);
  219.   XSetIconName(display,win,label);
  220.  
  221.   icon_pixmap = XCreateBitmapFromData(display, win, leda_icon_bits, 
  222.             leda_icon_width, leda_icon_height);
  223.  
  224.   size_hints.flags = PPosition;
  225.   size_hints.x = x;
  226.   size_hints.y = y;
  227.  
  228.   wm_hints.flags = StateHint | IconPixmapHint | InputHint;
  229.   wm_hints.initial_state = NormalState;
  230.   wm_hints.icon_pixmap = icon_pixmap;
  231.   wm_hints.input = True;
  232.   
  233.   XSetWMProperties(display,win,0,0,0,0,&size_hints,&wm_hints,0);
  234.  
  235.   XMapWindow(display,win);
  236.  
  237.   while (1) 
  238.   { XNextEvent(display, &e);
  239.     if (e.type == Expose) break;
  240.    }
  241.  
  242.   XDrawLine(display,win,gc,0,0,width-1,0);
  243.  
  244.   return win;
  245. }
  246.  
  247.  
  248. int display_width(void)
  249. { open_display();
  250.   return DisplayWidth(display,screen);  
  251.  }
  252.  
  253. int display_height(void)
  254. { open_display();
  255.   return DisplayHeight(display,screen); 
  256.  }
  257.  
  258. int display_depth(void)
  259. { open_display();
  260.   return DefaultDepth(display,screen); 
  261.  }
  262.  
  263. void flush_display(void)
  264. { XFlush(display); }
  265.  
  266. void close_display()
  267. { if (display) 
  268.   { XCloseDisplay(display); 
  269.     for(int i=0; i < color_count; i++) delete color_name[i];
  270.     display = 0; 
  271.    } 
  272. }
  273.  
  274. void close_window(Window win)
  275. { XDestroyWindow(display,win); }
  276.  
  277. void clear_window(Window win, int col)
  278. { /* XClearWindow(display,win);  */
  279.   int save_col = set_color(col);
  280.   int save_mode = set_mode(0);
  281.   box(win,1,1,window_width(win)-2,window_height(win)-2);
  282.   set_color(1);
  283.   rectangle(win,0,0,window_width(win)-1,window_height(win)-1);
  284.   set_color(save_col);
  285.   set_mode(save_mode);
  286. }
  287.  
  288.  
  289. void pixel(Window win, int x, int y)
  290. { XDrawPoint(display,win,gc,x,y); }
  291.  
  292.  
  293. void pixels(Window win, int n, int *x, int *y)
  294. { XPoint* points = new XPoint[n];
  295.   int i;
  296.   for(i=0; i<n; i++)
  297.   { points[i].x = (short)x[i];
  298.     points[i].y = (short)y[i];
  299.    }
  300.   XDrawPoints(display,win,gc,points,n,CoordModeOrigin);
  301.   delete points;
  302.  }
  303.  
  304.  
  305. void line(Window win, int x1, int y1, int x2, int y2)
  306. {
  307.    /* problems with clipping coordinates in [i*2^15..(i+1)*2^15-1], i odd  */
  308.  
  309.   if ((x1/(1<<15)) % 2) x1 = -x1;
  310.   if ((x2/(1<<15)) % 2) x2 = -x2;
  311.   if ((y1/(1<<15)) % 2) y1 = -y1;
  312.   if ((y2/(1<<15)) % 2) y2 = -y2;
  313.  
  314.   XDrawLine(display,win,gc,x1,y1,x2,y2); 
  315.  }
  316.  
  317.  
  318. void rectangle(Window win, int x1, int y1, int x2, int y2)
  319. { if (x1 > x2)
  320.   { int x = x1;
  321.     x1 = x2;
  322.     x2 = x;
  323.    }
  324.   if (y1 > y2)
  325.   { int y = y1;
  326.     y1 = y2;
  327.     y2 = y;
  328.    }
  329.   XDrawRectangle(display,win,gc,x1,y1,x2-x1,y2-y1);
  330. }
  331.  
  332.  
  333. void box(Window win, int x1, int y1, int x2, int y2)
  334. { if (x1 > x2)
  335.   { int x = x1;
  336.     x1 = x2;
  337.     x2 = x;
  338.    }
  339.   if (y1 > y2)
  340.   { int y = y1;
  341.     y1 = y2;
  342.     y2 = y;
  343.    }
  344.   XFillRectangle(display,win,gc,x1,y1,x2-x1+1,y2-y1+1);
  345. }
  346.  
  347.  
  348. void arc(Window win, int x0, int y0, int r1, int r2, double start, double angle)
  349. { int s = (int)(360*32*start/M_PI);
  350.   int a = (int)(360*32*angle/M_PI);
  351.   XDrawArc(display,win,gc,x0-r1,y0-r2,2*r1,2*r2,s,a);
  352. }
  353.  
  354.  
  355. void circle(Window win, int x0, int y0, int r)
  356. { XDrawArc(display,win,gc,x0-r,y0-r,2*r,2*r,0,360*64); }
  357.  
  358. void ellipse(Window win, int x0, int y0, int r1, int r2)
  359. { XDrawArc(display,win,gc,x0-r1,y0-r2,2*r1,2*r2,0,360*64); }
  360.  
  361.  
  362. void fill_arc(Window win, int x0, int y0, int r1, int r2, double start, double angle)
  363. { int s = (int)(360*32*start/M_PI);
  364.   int a = (int)(360*32*angle/M_PI);
  365.   XFillArc(display,win,gc,x0-r1,y0-r2,2*r1,2*r2,s,a);
  366. }
  367.  
  368. void fill_circle(Window win, int x0, int y0, int r)
  369. { XFillArc(display,win,gc,x0-r,y0-r,2*r,2*r,0,360*64); }
  370.  
  371.  
  372. void fill_ellipse(Window win, int x0, int y0, int r1, int r2)
  373. { XFillArc(display,win,gc,x0-r1,y0-r2,2*r1,2*r2,0,360*64); }
  374.  
  375.  
  376. void fill_polygon(Window win, int n, int *xcoord, int *ycoord)
  377. { XPoint* edges = new XPoint[n];
  378.   int i;
  379.   for(i=0;i<n;i++) 
  380.   { edges[i].x = (short) xcoord[i];
  381.     edges[i].y = (short) ycoord[i];
  382.    }
  383.  
  384.   XFillPolygon(display,win,gc,edges,n,Nonconvex,CoordModeOrigin);
  385.  
  386.   delete edges;
  387. }
  388.  
  389.  
  390. void put_text(Window win, int x, int y, const char* s, int opaque)
  391. { y += current_font->ascent;
  392.   if (opaque)
  393.      XDrawImageString(display,win,gc,x,y,s,strlen(s));
  394.   else
  395.      XDrawString(display,win,gc,x,y,s,strlen(s));
  396. }
  397.  
  398.  
  399. void put_ctext(Window win, int x, int y, const char* s, int opaque)
  400. { x -= text_width(s)/2;
  401.   y -= text_height(s)/2;
  402.   put_text(win,x,y,s,opaque);
  403.  }
  404.  
  405.  
  406. void show_coordinates(Window win, const char* s)
  407. { put_text(win,window_width(win)-160,2,s,1); }
  408.  
  409.  
  410. int text_width(const char* s)
  411. { return current_char_width * strlen(s); }
  412.  
  413.  
  414. int text_height(const char*)
  415. { return(current_font->ascent+current_font->descent/2); }
  416.  
  417.  
  418. void copy_rect(Window win, int x1, int y1, int x2, int y2, int x, int y)
  419. {
  420.   int save = set_mode(0);   /* src-mode */
  421.  
  422.   Pixmap P=XCreatePixmap(display,win,x2-x1,y2-y1,DefaultDepth(display,screen));
  423.  
  424.   XCopyArea(display,win,P,gc, x1,y1,x2-x1,y2-y1,0,0);
  425.   XCopyArea(display,P,win,gc,0,0,x2-x1,y2-y1,x,y);
  426.  
  427.   set_mode(save);
  428.  }
  429.  
  430. void insert_bitmap(Window win, int width, int height, char* data)
  431. { int save = set_mode(0);
  432.   Pixmap P=XCreatePixmapFromBitmapData(display,win,data,width,height,
  433.                                        BlackPixel(display,screen), 
  434.                                        WhitePixel(display,screen), 
  435.                                        DefaultDepth(display,screen));
  436.   XCopyArea(display,P,win,gc,0,0,width,height,0,0);
  437.   set_mode(save);
  438.  }
  439.  
  440.  
  441. void set_header(Window win, const char* s)
  442. { XStoreName(display,win,s); }
  443.  
  444.  
  445. int set_color(int col)
  446. { int save = COLOR;
  447.   COLOR = col;
  448.   gc_val.foreground = color_pix[col];
  449.   XChangeGC(display,gc,GCForeground,&gc_val);
  450.   return col;
  451.  }
  452.  
  453.  
  454. int set_mode(int m)
  455. { int save = MODE;
  456.  
  457.   MODE = m;
  458.  
  459.   switch (m)  {
  460.  
  461.    case 0 : gc_val.function = GXcopy;
  462.             break;
  463.  
  464.    case 1 : gc_val.function = GXxor;
  465.             break;
  466.  
  467.    case 2 : gc_val.function = GXor;
  468.             break;
  469.  
  470.   }
  471.  
  472.   XChangeGC(display,gc,GCFunction,&gc_val);
  473.  
  474.   return save;
  475. }
  476.  
  477.  
  478. int load_text_font(const char* font_name)
  479. { XFontStruct* fp = XLoadQueryFont(display,font_name);
  480.   if (fp)  
  481.   { text_font = fp;
  482.     text_char_width = get_char_width(fp);
  483.    }
  484.   return (fp != NULL);
  485.  }
  486.  
  487.  
  488. int load_bold_font(const char* font_name)
  489. { XFontStruct* fp = XLoadQueryFont(display,font_name);
  490.   if (fp)  
  491.   { bold_font = fp;
  492.     bold_char_width = get_char_width(fp);
  493.    }
  494.   return (fp != NULL);
  495.  }
  496.  
  497.  
  498. int load_message_font(const char* font_name)
  499. { XFontStruct* fp = XLoadQueryFont(display,font_name);
  500.   if (fp)  
  501.   { mesg_font = fp;
  502.     mesg_char_width = get_char_width(fp);
  503.    }
  504.   return (fp != NULL);
  505.  }
  506.  
  507.  
  508. int set_font(const char *fname)
  509. { XFontStruct* fp = XLoadQueryFont(display,fname);
  510.   if (fp)
  511.   { current_font = fp;
  512.     current_char_width = get_char_width(fp);
  513.     gc_val.font = fp->fid;
  514.     XChangeGC(display,gc,GCFont,&gc_val);
  515.    }
  516.   return (fp != NULL);
  517.  }
  518.  
  519.  
  520. void set_text_font(void)
  521. { current_font = text_font;
  522.   gc_val.font = text_font->fid;
  523.   XChangeGC(display,gc,GCFont,&gc_val);
  524.   current_char_width = text_char_width;
  525.  }
  526.  
  527.  
  528. void set_bold_font(void)
  529. { current_font = bold_font;
  530.   gc_val.font = bold_font->fid;
  531.   XChangeGC(display,gc,GCFont,&gc_val);
  532.   current_char_width = bold_char_width;
  533.  }
  534.  
  535.  
  536. void set_message_font(void)
  537. { current_font = mesg_font;
  538.   gc_val.font = mesg_font->fid;
  539.   XChangeGC(display,gc,GCFont,&gc_val);
  540.   current_char_width = mesg_char_width;
  541.  }
  542.  
  543.  
  544.  
  545. int set_line_width(int w)
  546. { int save = gc_val.line_width;
  547.   gc_val.line_width = w;
  548.   XChangeGC(display,gc,GCLineWidth,&gc_val);
  549.   return save;
  550. }
  551.  
  552.  
  553. int set_line_style(int s)
  554. { 
  555.   int save = LINESTYLE;
  556.  
  557.   LINESTYLE = s;
  558.  
  559.   switch (s)  {
  560.  
  561.    case 0 : gc_val.line_style = LineSolid;
  562.             break;
  563.  
  564.    case 1 : gc_val.line_style = LineOnOffDash;
  565.             XSetDashes(display,gc,0,dash_mask,2);
  566.             break;
  567.  
  568.    case 2 : gc_val.line_style = LineOnOffDash;
  569.             XSetDashes(display,gc,0,dot_mask,2);
  570.             break;
  571.    }
  572.  
  573.   XChangeGC(display,gc,GCLineStyle,&gc_val);
  574.   return save;
  575. }
  576.  
  577.  
  578. void set_read_gc(void)
  579. {XGCValues gc_val0;
  580.  gc_val0.function = GXxor; 
  581.  gc_val0.foreground = BlackPixel(display,screen); 
  582.  gc_val0.line_style = LineSolid;
  583.  gc_val0.line_width = 1;
  584.  XChangeGC(display,gc,GCForeground|GCFunction|GCLineStyle|GCLineWidth,&gc_val0);
  585.  flush_display();
  586. }
  587.  
  588. void reset_gc(void)
  589. { XChangeGC(display,gc,GCForeground|GCFunction|GCLineStyle|GCLineWidth,&gc_val);
  590.   flush_display();
  591. }
  592.  
  593.  
  594. int window_height(Window win)
  595. { Window w;
  596.   int xpos,ypos;
  597.   unsigned width,height,bw,dep;
  598.   XGetGeometry(display,win,&w,&xpos,&ypos,&width,&height,&bw,&dep);
  599.   return height;
  600.  }
  601.  
  602. int window_width(Window win)
  603. { Window w;
  604.   int xpos,ypos;
  605.   unsigned width,height,bw,dep;
  606.   XGetGeometry(display,win,&w,&xpos,&ypos,&width,&height,&bw,&dep);
  607.   return width;
  608.  }
  609.  
  610.  
  611. void window_position(Window win, int *x, int *y)
  612. { XSizeHints size_hints;
  613.   long flags = PPosition;
  614.   XGetWMNormalHints(display,win,&size_hints,&flags);
  615.   *x = size_hints.x;
  616.   *y = size_hints.y;
  617.  }
  618.  
  619.  
  620. static int  handle_event(Window *win,int *val,int *x,int *y,unsigned long *t)
  621. {
  622.   KeySym keysym;
  623.   XComposeStatus status;
  624.  
  625.   int  kind;
  626.   char c;
  627.  
  628.   *win = event.xany.window;
  629.   *val = 0;
  630.  
  631.   switch (event.type) {
  632.  
  633.   case ConfigureNotify: kind = configure_event;
  634.                         *x = event.xconfigure.width;
  635.                         *y = event.xconfigure.height;
  636.                         break;
  637.  
  638.   case DestroyNotify: kind = destroy_event;
  639.                       break;
  640.  
  641.   case ButtonPress: *val = event.xbutton.button;
  642.                     *x = event.xbutton.x;
  643.                     *y = event.xbutton.y;
  644.                     *t = event.xbutton.time;
  645.                     kind = button_press_event;
  646.                     if (event.xbutton.state & Mod1Mask) *val = 2; 
  647.                     if (event.xbutton.state & ShiftMask) *val = -*val;
  648.                     if (event.xbutton.state & ControlMask) *val += 3;
  649.                     break;
  650.  
  651.   case ButtonRelease: *val = event.xbutton.button;
  652.                       *x = event.xbutton.x;
  653.                       *y = event.xbutton.y;
  654.                       *t = event.xbutton.time;
  655.                       if (event.xbutton.state & Mod1Mask) *val = 2; 
  656.                       if (event.xbutton.state & ShiftMask) *val = -*val;
  657.                       if (event.xbutton.state & ControlMask) *val += 3;
  658.                       kind = button_release_event;
  659.                       break;
  660.  
  661.   case MotionNotify: *x = event.xmotion.x;
  662.                      *y = event.xmotion.y;
  663.                      kind = motion_event;
  664.                      break;
  665.  
  666.   case KeyPress: *x = event.xmotion.x;
  667.                  c = 0;
  668.                  XLookupString((XKeyEvent*)&event,&c,1, &keysym, &status);
  669.                  *val = c;
  670.                  kind = key_press_event;
  671.                  break;
  672.  
  673.   }
  674.  
  675.   return kind;
  676. }
  677.  
  678.  
  679. int check_next_event(Window *win, int *val, int *x, int *y, unsigned long *t) 
  680. { // non-blocking 
  681.  
  682.   if (XCheckMaskEvent(display, 
  683.                       KeyPressMask    | // PointerMotionMask  | 
  684.                       ButtonPressMask | ButtonReleaseMask  |
  685.                       ExposureMask    | StructureNotifyMask, &event) == 0) 
  686.       return no_event; 
  687.  
  688.   return handle_event(win,val,x,y,t);
  689. }
  690.  
  691.  
  692. int get_next_event(Window *win, int *val, int *x, int *y, unsigned long *t)
  693. { // blocking
  694.  
  695.   XNextEvent(display, &event);
  696.   return handle_event(win,val,x,y,t);
  697. }
  698.  
  699.  
  700.  
  701. void put_back_event(void)
  702. { XPutBackEvent(display,&event); }
  703.  
  704.